home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / radio / checkradio.py < prev    next >
Encoding:
Python Source  |  1994-08-02  |  8.5 KB  |  340 lines
  1. # /***********************************************************
  2. # Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
  3. # Amsterdam, The Netherlands.
  4. # 
  5. #                         All Rights Reserved
  6. # 
  7. # Permission to use, copy, modify, and distribute this software and its 
  8. # documentation for any purpose and without fee is hereby granted, 
  9. # provided that the above copyright notice appear in all copies and that
  10. # both that copyright notice and this permission notice appear in 
  11. # supporting documentation, and that the names of Stichting Mathematisch
  12. # Centrum or CWI not be used in advertising or publicity pertaining to
  13. # distribution of the software without specific, written prior permission.
  14. # 
  15. # STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. # THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. # FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. # FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22. # 
  23. # ******************************************************************/
  24.  
  25. # Continuously check radio transmissions on one or more ports.
  26. # After an idea of Behr de Ruiter.
  27. #
  28. # usage: checkradio [-t] [port] ...
  29. #
  30. # Ports are given as command line arguments, default is radio's default.
  31. # Shorthands 1..99 can be used as for radio's -p argument.
  32. #
  33. # With the -t option, repeatedly print status for each port argument.
  34. # Without -t, pop up a GL window displaying the CD file if there is noise.
  35.  
  36. # For best results, use /ufs/guido/bin/sgi/python to execute this.
  37. # Don't make the file executable; then dynamic loading of audioop fails!
  38.  
  39. # XXX To do:
  40. # - need an option to suppress looping when using -t
  41. # - need a `status only' option that sets exit status only
  42. # - DELAY and LOOP should be under control of command line options
  43. # - add options to specify font, colors and so on
  44. # - optionally tune radio to the first station transmitting noise
  45. # - should listen to info packets instead
  46. # - move the symbolic constants and some subroutines to separate modules
  47.  
  48.  
  49. import sys
  50. import socket
  51. import audioop
  52. import string
  53. import time
  54. import os
  55. from stat import *
  56. from SOCKET import *
  57. import getopt
  58.  
  59.  
  60. # Parametrizations
  61.  
  62. CTL_PORT = 54319            # control port
  63. PORT_OFFSET = 54320            # port offset if 1 <= port <= 99
  64. DEF_PORT = 54321            # default port (if no args)
  65. LOOP = 15                # listen for this many tenths seconds
  66. DELAY = 10                # seconds between successive tries
  67. LIMIT = 256                # silence threshold
  68. BUFSIZE = 1500                # read buffer size
  69.  
  70.  
  71. # Status constants returned by checkport()
  72.  
  73. TUNED = 'already tuned in'
  74. BINDFAILURE = 'bind failure'
  75. DEAD = 'not transmitting'
  76. SILENT = 'transmitting silence'
  77. NOISY = 'transmitting'
  78.  
  79.  
  80. # Main program
  81.  
  82. def main():
  83.     try:
  84.         optlist, args = getopt.getopt(sys.argv[1:], 'tx:y:')
  85.     except getopt.error:
  86.         sys.stdout = sys.stderr
  87.         print 'usage: checkradio',
  88.         print '[-x xorg] [-y yorg] [-t] [port] ...'
  89.         print '-x xorg, -y yorg: left top origin of window',
  90.         print '(negative values: right bottom)'
  91.         print '-t: tty mode output (looping), no window'
  92.         sys.exit(2)
  93.     #
  94.     do_win = 1
  95.     x, y = 140, 4
  96.     for opt, arg in optlist:
  97.         if opt == '-t':
  98.             do_win = 0
  99.         elif opt == '-x':
  100.             x = int(eval(arg))
  101.         elif opt == '-y':
  102.             y = int(eval(arg))
  103.     #
  104.     ports = []
  105.     for arg in args:
  106.         p = int(eval(arg))
  107.         if 1 <= p <= 99:
  108.             p = p + PORT_OFFSET
  109.         ports.append(p)
  110.     if not ports:
  111.         ports.append(DEF_PORT)
  112.     #
  113.     if do_win:
  114.         wincode(ports, (x, y))
  115.     else:
  116.         ttycode(ports)
  117.  
  118.  
  119. # Code for tty version
  120.  
  121. def ttycode(ports):
  122.     while 1:
  123.         for p in ports:
  124.             print 'port', p, ':',
  125.             sys.stdout.flush()
  126.             status, sender = checkport(p)
  127.             if status in (NOISY, SILENT):
  128.                 cdname = getinfostring(p, sender)
  129.                 if cdname:
  130.                     status = status + ': ' + cdname
  131.             print status
  132.         time.sleep(DELAY)
  133.  
  134. def getinfostring(port, sender):
  135.     name, port, transmitting, logfile, age, contents = \
  136.         getinfo(port, sender)
  137.     if 0 <= age < 99999:
  138.         contents = contents + ' (' + formatage(age) + ')'
  139.     return contents
  140.  
  141. def formatage(age):
  142.     if age < 60: return `age` + ' sec'
  143.     if age < 3600: return `age/60` + ' min'
  144.     if age < 24*3600: return `age/3600` + ' hrs'
  145.     return `age/(24*3600)` + ' days'
  146.  
  147.  
  148. # Code for GL window version
  149.  
  150. # Parameters
  151. timer_rate = 60 # Seconds
  152. color_choices = [95, 94, 93, 92, 91, 90, 89, 88]
  153.  
  154. def wincode(ports, org):
  155.     if len(ports) > 1:
  156.         sys.stderr.write('warning: only the first port arg is used\n')
  157.     port = ports[0]
  158.     import gl, GL, DEVICE, fm
  159.     #gl.foreground()
  160.     fh = fm.findfont('Helvetica').scalefont(8)
  161.     fh.setfont()
  162.     str, age = getinfopair(port)
  163.     # Always create the window initially -- to initialize gl
  164.     wid = createwin(org, fh, str)
  165.     gl.qdevice(DEVICE.TIMER1)
  166.     gl.noise(DEVICE.TIMER1, timer_rate*60) # 60th of a second
  167.     while 1:
  168.         dev, val = gl.qread()
  169.         if dev == DEVICE.REDRAW:
  170.             redraw_window(wid, str, age)
  171.         elif dev == DEVICE.TIMER1:
  172.             oldstr = str
  173.             str, age = getinfopair(port)
  174.             if str <> oldstr:
  175.                 if wid > 0:
  176.                     org = currentorg(org)
  177.                     deletewin(wid)
  178.                     wid = -1
  179.                 if str:
  180.                     wid = createwin(org, fh, str)
  181.             elif wid > 0:
  182.                 redraw_window(wid, str, age)
  183.  
  184. def currentorg((oldx, oldy)):
  185.     import gl, GL
  186.     x, y = gl.getorigin()
  187.     if oldx >= 0 and oldy >= 0: return (oldx, oldy)
  188.     xsize, ysize = gl.getsize()
  189.     xmax = gl.getgdesc(GL.GD_XPMAX)
  190.     ymax = gl.getgdesc(GL.GD_YPMAX)
  191.     if oldx < 0:
  192.         x = (x + xsize) - (xmax+1)
  193.         if x >= 0: x = -1
  194.     if oldy < 0:
  195.         y = (y + ysize) - (ymax+1)
  196.         if y >= 0: y = -1
  197.     return x, y
  198.  
  199. def redraw_window(wid, str, age):
  200.     import gl, GL, fm
  201.     mins = age/60 # Convert to minutes
  202.     
  203.     gl.color(color_choices[min(max(0, mins/9), len(color_choices)-1)])
  204.     gl.clear()
  205.     
  206.     gl.color(GL.BLACK)
  207.  
  208.     xsize, ysize = gl.getsize()
  209.     gl.bgnclosedline()
  210.     gl.v2i(0, 0)
  211.     gl.v2i(0, ysize-1)
  212.     gl.v2i(xsize-1, ysize-1)
  213.     gl.v2i(xsize-1, 0)
  214.     gl.endclosedline()
  215.  
  216.     gl.cmov2i(4, 4)
  217.     fm.prstr(str)
  218.  
  219. def createwin((x, y), fh, str):
  220.     import gl, GL, DEVICE
  221.     gl.noborder()
  222.     xsize = fh.getstrwidth(str) + 7
  223.     ysize = 16
  224.     if x < 0 or y < 0:
  225.         xmax = gl.getgdesc(GL.GD_XPMAX)
  226.         ymax = gl.getgdesc(GL.GD_YPMAX)
  227.         if x < 0: x = x + (xmax+1) - xsize
  228.         if y < 0: y = y + (ymax+1) - ysize
  229.     gl.prefposition(x, x + xsize, y, y + ysize)
  230.     wid = gl.winopen('checkradio')
  231.     gl.qenter(DEVICE.REDRAW, wid)
  232.     return wid
  233.  
  234. def deletewin(wid):
  235.     import gl, GL, DEVICE
  236.     gl.winclose(wid)
  237.  
  238. def getinfopair(port):
  239.     state, sender = checkport(port)
  240.     if state not in (NOISY, SILENT):
  241.         return '', 99999
  242.     name, port, transmitting, logfile, age, contents = \
  243.         getinfo(port, sender)
  244.     return contents, age
  245.  
  246.  
  247. # Common code
  248.  
  249. def checkport(port):
  250.     s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  251.     try:
  252.         s.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
  253.     except socket.error:
  254.         print 'warning: cannot set socket option SO_REUSEPORT'
  255.     try:
  256.         s.bind('', port)
  257.     except socket.error, msg:
  258.         if msg == (114, 'Address already in use'):
  259.             return TUNED, msg
  260.         else:
  261.             return BINDFAILURE, msg
  262.     transmitting = 0
  263.     noise = 0
  264.     sender = None
  265.     for i in range(LOOP):
  266.         if i: time.millisleep(100)
  267.         while s.avail():
  268.             data, sender = s.recvfrom(BUFSIZE)
  269.             if data[:6] == 'radio:': continue
  270.             transmitting = 1
  271.             lindata = audioop.ulaw2lin(data, 2)
  272.             n = audioop.max(lindata, 2)
  273.             if n > LIMIT:
  274.                 noise = n
  275.                 break
  276.         if noise: break
  277.     s.close()
  278.     if not transmitting:
  279.         return DEAD, sender
  280.     if not noise:
  281.         return SILENT, sender
  282.     return NOISY, sender
  283.  
  284. def getinfo(port, sender):
  285.     s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  286.     s.sendto('radio:s', (sender[0], CTL_PORT))
  287.     for i in range(LOOP):
  288.         time.millisleep(100)
  289.         while s.avail():
  290.             data, realsender = s.recvfrom(BUFSIZE)
  291.             if data[:7] == 'radio:S':
  292.                 return decodeinfo(data)
  293.  
  294. def decodeinfo(data):
  295.     fields = string.splitfields(data, ':')
  296.     name = fields[2]
  297.     port = eval(fields[3])
  298.     if fields[4:]:
  299.         transmitting = eval(fields[4])
  300.         logfile = fields[5]
  301.         age = eval(fields[6])
  302.         contents = string.joinfields(fields[7:], ':')
  303.     else:
  304.         transmitting = -1
  305.         programfile = '/ufs/' + name + '/CD'
  306.         logfile = programfile + 'log'
  307.         age = getage(programfile)
  308.         if age == None:
  309.             age = -1
  310.         contents = getcontents(programfile)
  311.         if contents == None:
  312.             contents = '???'
  313.     return name, port, transmitting, logfile, age, contents
  314.     return None
  315.  
  316. def getcontents(filename):
  317.     try:
  318.         f = open(filename, 'r')
  319.     except IOError:
  320.         return None
  321.     res = f.readline()
  322.     f.close()
  323.     return string.strip(res)
  324.  
  325. def getage(filename):
  326.     try:
  327.         st = os.stat(filename)
  328.     except os.error:
  329.         return None
  330.     return time.time() - st[ST_MTIME]
  331.  
  332.  
  333. # Call the main program
  334.  
  335. try:
  336.     main()
  337. except KeyboardInterrupt:
  338.     print
  339.     print '[Interrupt]'
  340.